////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-2017 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camximagesensormoduledatamanager.h
/// @brief Image sensor module data manager declaration
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXIMAGESENSORMODULEDATAMANAGER_H
#define CAMXIMAGESENSORMODULEDATAMANAGER_H

#include "camxdefs.h"
#include "camxtypes.h"
#include "camximagesensormoduledata.h"

// Forward declarations
class HwEnvironment;

CAMX_NAMESPACE_BEGIN


/// @brief specifies maximum number supported sensor modules
static const UINT16 MaxSensorModules        = 50;


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Type definitions
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief  Class to manage the set of sensor module data objects available in the system. The objects managed by this class are
///         not necessarily present on the device. Data objects can be used to probe the device to discover what image sensor
///         module is actually installed.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class ImageSensorModuleDataManager
{
public:

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create an instance of the ImageSensorModuleDataManager
    ///
    /// @param  ppManager   ImageSensorModuleDataManager output.
    /// @param  pEnv        pointer to the HwEnvironment creating this
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
            ImageSensorModuleDataManager** ppManager,
            HwEnvironment*                 pEnv);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destroy
    ///
    /// @brief  Destroy this instance of the ImageSensorModuleDataManager.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID Destroy();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetNumberOfImageSensorModuleData
    ///
    /// @brief  Return the number of ImageSensorModuleData objects available.
    ///
    /// @return The number of ImageSensorModuleData objects.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT GetNumberOfImageSensorModuleData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetImageSensorModuleData
    ///
    /// @brief  Retrieve and ImageSensorModuleData object.
    ///
    /// @param  index   Index of the object to retrieve. Index is 0 based. Must be less than GetNumberOfImageSensorModuleData.
    ///
    /// @return A pointer to an ImageSensorModuleData. NULL if no valid object at the provided index.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ImageSensorModuleData* GetImageSensorModuleData(
        UINT index
        ) const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetHwEnvironment
    ///
    /// @brief  Return the pointer to the HwEnvironment
    ///
    /// @return Pointer to the HwEnvironment
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    HwEnvironment* GetHwEnvironment()
    {
        return m_pEnv;
    }

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~ImageSensorModuleDataManager
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ~ImageSensorModuleDataManager() = default;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ImageSensorModuleDataManager
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ImageSensorModuleDataManager() = default;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Initialize this instance of the ImageSensorModuleDataManager
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult Initialize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Uninitialize
    ///
    /// @brief  Uninitialize this instance of the ImageSensorModuleDataManager.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID Uninitialize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateAllSensorModuleSetManagers
    ///
    /// @brief  Discover sensor module data objects from filesystem or other location
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateAllSensorModuleSetManagers();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SortSensorDataObjects
    ///
    /// @brief  Sort sensor data objects as the order REAR/FRONT/REAR_AUX/FRONT_AUX
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID SortSensorDataObjects();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetSensorModuleManagerObj
    ///
    /// @brief  Opens the binary and returns the object of SensorManager
    ///
    /// @param  pName                       Name of the module binary
    /// @param  ppSensorModuleSetManager    pointer to pointer to Sensor module manager object
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetSensorModuleManagerObj(
        const CHAR*                   pName,
        ImageSensorModuleSetManager** ppSensorModuleSetManager);

    ImageSensorModuleDataManager(const ImageSensorModuleDataManager&)            = delete;///< Disallow the copy constructor.
    ImageSensorModuleDataManager& operator=(const ImageSensorModuleDataManager&) = delete;///< Disallow assignment operator.

    ImageSensorModuleSetManager* m_pSensorModuleManagers[MaxSensorModules];               ///< Array of pointers
                                                                                          ///  to ImageSensorModuleSetManager
    UINT                         m_numSensorModuleManagers;                               ///< Number of image sensor data
                                                                                          ///  objects in platform
    ImageSensorModuleData**      m_ppDataObjs;                                            ///< Pointer to array of pointers
                                                                                          ///   to data objects
    UINT                         m_numberOfDataObjs;                                      ///< number of data objects
                                                                                          ///   in m_pDataObjects
    HwEnvironment*               m_pEnv;                                                  ///< pointer to the HwEnvironment
};

CAMX_NAMESPACE_END

#endif // CAMXIMAGESENSORMODULEDATAMANAGER_H
